package self.xine.basic.thread.other;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 当需要执行大量生命周期很短的任务时，若为每个任务都创建一个线程，则开销过于庞大，内存占用过高。
 * 	此时，可以通过线程执行器，来限制同时执行的任务数量，且不需要创建大量的线程。
 * 	
 * 	线程执行器，提供了一组空闲的线程。通过将任务提交给它，便可以执行。
 * 
 *   submit 有返回值,返回值通常为线程执行的结果
 *   execute没有返回值
 * 
 * 
 * @author xine
 * @date 2018年9月8日
 */
public class ExcecutorDemo {

	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		List<Future<Integer>> resultList = new ArrayList<>();//用于保存各线程的执行结果
		
		for(int i = 0; i< 20; i++) {
			Future<Integer> future = executorService.submit(new MyCallable("test" + i));
			resultList.add(future);
		}
				
		for(Future<Integer> result : resultList) {
			try {
				System.out.println(System.currentTimeMillis());
				System.out.println(result.get());//该方法会被阻塞，直至线程执行完毕
				System.out.println(System.currentTimeMillis());
				System.out.println();
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}		
				
	}	
}

class MyCallable implements Callable<Integer> {
	
	private String name;
	
	public MyCallable(String name) {
		this.name = name;
	}

	@Override
	public Integer call() throws Exception {
		System.out.println(Thread.currentThread().getName() + "  " + name);	
		
		return new Random().nextInt(10);		
	}
}

